src/transaction/update_transaction.cc, line 738-746 (link)

Redo log serialized before capacity check — inconsistent transaction state on failure

InsertEdgeRedo::Serialize and op_num_ += 1 are executed on lines 738–741 before EnsureCapacity is checked on line 742. If EnsureCapacity returns an error (e.g., the edge label triplet doesn't exist), the function returns false but the redo log (arc_) already contains a serialized edge entry and op_num_ has been incremented. This leaves the transaction's redo log in an inconsistent state and could cause incorrect replay during crash recovery.

This is directly inconsistent with the pattern used in the AddVertex function in this same file (lines 683–691), which correctly calls EnsureCapacity before calling InsertVertexRedo::Serialize and incrementing op_num_.

The fix is to move the EnsureCapacity call (and early return on failure) before the serialize/increment:

src/transaction/update_transaction.cc, line 738-746 (link)

Redo log serialized before capacity check — transaction log corruption on failure

InsertEdgeRedo::Serialize (line 738) and op_num_ += 1 (line 741) execute before EnsureCapacity is checked. If EnsureCapacity returns an error and the function returns false, the redo log entry has already been appended and op_num_ incremented, but the edge was never actually inserted. This leaves the transaction log in an inconsistent state and could cause incorrect replay during recovery.

This is directly inconsistent with the fixed AddVertex path in the same file (lines 683–692), where serialization is correctly placed after the capacity check:

// AddVertex (correct ordering):
auto status = graph_.EnsureCapacity(label);
if (!status.ok()) { return false; }
InsertVertexRedo::Serialize(arc_, label, oid, props);
op_num_ += 1;
status = graph_.AddVertex(...);

The AddEdge block should follow the same pattern:

auto status = graph_.EnsureCapacity(src_label, dst_label, edge_label);
if (!status.ok()) {
  LOG(ERROR) << "Failed to ensure space before insert edge: "
             << status.ToString();
  return false;
}
InsertEdgeRedo::Serialize(arc_, src_label, GetVertexId(src_label, src_lid),
                          dst_label, GetVertexId(dst_label, dst_lid),
                          edge_label, properties);
op_num_ += 1;
auto oe_offset = graph_.AddEdge(...);

src/transaction/update_transaction.cc, line 738-746 (link)

Redo log serialized before capacity check

InsertEdgeRedo::Serialize (line 738) and op_num_ += 1 (line 741) are called before EnsureCapacity (line 742). If EnsureCapacity fails and the function returns false, the WAL already contains the edge-insert entry and op_num_ has been incremented — but the edge was never actually written to the graph.

On WAL replay after a crash at this point, the replayed edge insertion would fail again (or worse, succeed spuriously with uninitialised capacity), corrupting the graph state.

The AddVertex path (line 683) does this correctly: it calls EnsureCapacity first, and only then serializes the redo entry. AddEdge should follow the same ordering:

// Correct order — mirror AddVertex:
auto status = graph_.EnsureCapacity(src_label, dst_label, edge_label);
if (!status.ok()) {
  LOG(ERROR) << "Failed to ensure space before insert edge: " << status.ToString();
  return false;
}
InsertEdgeRedo::Serialize(arc_, src_label, GetVertexId(src_label, src_lid),
                          dst_label, GetVertexId(dst_label, dst_lid),
                          edge_label, properties);
op_num_ += 1;

src/storages/graph/edge_table.cc, line 263-264 (link)

reserve reserves 0 instead of the intended size

edge_data is freshly default-constructed, so edge_data.size() is 0. The call edge_data.reserve(edge_data.size()) is a no-op and the intent was clearly to pre-allocate property_vec.size() slots to avoid repeated reallocations during the loop below.

include/neug/utils/mmap_array.h, line 365-380 (link)

avg_size() is O(n) and is called in a resize hot path

avg_size() iterates over every item in the buffer to compute the average string length. This is called from TypedColumn<std::string_view>::resize, which is invoked from insert_vertices_impl whenever the vertex table grows. For tables with millions of string-typed properties, this becomes an O(n) scan inside what is essentially the capacity-growth logic, adding significant overhead that scales with the number of existing entries.

Consider tracking the running total length incrementally (e.g., as an atomic member updated on each set call) rather than recomputing it on every call:

size_t avg_size() const {
  // total_data_length_ and non_zero_count_ could be maintained incrementally
  return non_zero_count_ > 0 ? (total_data_length_ + non_zero_count_ - 1) / non_zero_count_ : 0;
}

Alternatively, cap the sample to the first N entries (e.g., 1024) to bound the cost.

include/neug/utils/property/column.h, line 522-527 (link)

pos_ initialized to 0 when .pos file is absent — corrupts strings on first post-dump insert

When the .pos file does not exist (e.g., first open from a freshly-created or migrated database before any Dump), pos_ is set to 0. If the column was opened from an existing checkpoint that already contains string data (the .items and .data files were copied from elsewhere), new string inserts will start writing at offset 0, silently overwriting all previously stored string values.

The pre-existing behavior in all four open* paths was:

pos_ = buffer_.data_size();

which safely positions the write cursor at the end of existing data. The new init_pos no longer does this as a fallback.

When the .pos file does not exist, falling back to buffer_.data_size() (the actual used extent) rather than 0 would be the safe default:

inline void init_pos(const std::string& file_path) {
  if (std::filesystem::exists(file_path)) {
    read_file(file_path, &pos_, sizeof(pos_), 1);
  } else {
    pos_.store(buffer_.data_size());  // safe fallback: append after existing data
  }
}